Fixes #43.
Fixes #110.

This basically allows:

let t = task { return 10 } :> Task  // ignore by casting to Task
let ts = taskSeq { do! t } // currently not supported, must be Task<unit>
let ts = taskSeq { do! Task.Delay 10 } // currently not supported

On top of that, this PR will add support for all of ^TaskLike that F#'s task also supports. This change is necessary, as the above distinction isn't possible by adding an overload for the non-generic Task and ValueTask, for the simple reason that Task<'T> :> Task.

The solution chosen in F# was to have a Bind implementation that takes an SRTP parameter of ^TaskLike, which has a GetAwaiter() -> 'T when 'T :> ICriticalNotifyCompletion, as follows:

member inline _.Bind< ^TaskLike, 'TResult1, 'TResult2, ^Awaiter, 'TOverall
    when ^TaskLike: (member GetAwaiter: unit -> ^Awaiter)
    and ^Awaiter :> ICriticalNotifyCompletion
    and ^Awaiter: (member get_IsCompleted: unit -> bool)
    and ^Awaiter: (member GetResult: unit -> 'TResult1)

    ... resumable code implementation ...

Because Task<'T> does have a GetAwaiter on the type, but also inherits Task which in turn implements the non-generic TaskAwaiter, a conflict arises causing an "ambiguous overload" error with just the code above. To solve this, a high-priority overload Bind for Task<'T> is added, which specifically pick the Task<'T>.GetAwaiter: unit -> TaskAwaiter<'T>, as opposed to (Task<'T> :> Task).GetAwaiter: unit -> unit.

Note that the non-generic Task only has the non-generic GetResult: unit -> unit, which fits the above signature where 'TResult1 becomes unit, and no ambiguity arises.

In other words, TaskLike are: ValueTask, ValueTask<'T>, Task. Not TaskLike per the above definition is Task<'T>, which has its own overload.